home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / elispman.lha / elispman / elisp-23 (.txt) < prev    next >
GNU Info File  |  1993-06-01  |  49KB  |  861 lines

  1. This is Info file elisp, produced by Makeinfo-1.55 from the input file
  2. elisp.texi.
  3.    This is edition 2.0 of the GNU Emacs Lisp Reference Manual, for
  4. Emacs Version 19.
  5.    Published by the Free Software Foundation, 675 Massachusetts Avenue,
  6. Cambridge, MA 02139 USA
  7.    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.    Permission is granted to copy and distribute modified versions of
  12. this manual under the conditions for verbatim copying, provided that
  13. the entire resulting derived work is distributed under the terms of a
  14. permission notice identical to this one.
  15.    Permission is granted to copy and distribute translations of this
  16. manual into another language, under the above conditions for modified
  17. versions, except that this permission notice may be stated in a
  18. translation approved by the Foundation.
  19. File: elisp,  Node: The Kill Ring,  Next: Undo,  Prev: User-Level Deletion,  Up: Text
  20. The Kill Ring
  21. =============
  22.    "Kill" functions delete text like the deletion functions, but save
  23. it so that the user can reinsert it by "yanking".  Most of these
  24. functions have `kill-' in their name.  By contrast, the functions whose
  25. names start with `delete-' normally do not save text for yanking
  26. (though they can still be undone); these are "deletion" functions.
  27.    Most of the kill commands are primarily for interactive use, and are
  28. not described here.  What we do describe are the functions provided for
  29. use in writing such commands.  When deleting text for internal purposes
  30. within a Lisp function, you should normally use deletion functions, so
  31. as not to disturb the kill ring contents.  *Note Deletion::.
  32.    Emacs saves the last several batches of killed text in a list.  We
  33. call it the "kill ring" because, in yanking, the elements are
  34. considered to be in a cyclic order.  The list is kept in the variable
  35. `kill-ring', and can be operated on with the usual functions for lists;
  36. there are also specialized functions, described in this section, which
  37. treat it as a ring.
  38.    Some people think use of the word "kill" in Emacs is unfortunate,
  39. since it refers to processes which specifically *do not* destroy the
  40. entities "killed".  This is in sharp contrast to ordinary life, in
  41. which death is permanent and "killed" entities do not come back to
  42. life.  Therefore, other metaphors have been proposed.  For example, the
  43. term "cut ring" makes sense to people who, in pre-computer days, used
  44. scissors and paste to cut up and rearrange manuscripts.  However, it
  45. would be difficult to change now.
  46. * Menu:
  47. * Kill Ring Concepts::     What text looks like in the kill ring.
  48. * Kill Functions::         Functions that kill text.
  49. * Yank Commands::          Commands that access the kill ring.
  50. * Low Level Kill Ring::       Functions and variables for kill ring access.
  51. * Internals of Kill Ring:: Variables that hold kill-ring data.
  52. File: elisp,  Node: Kill Ring Concepts,  Next: Kill Functions,  Up: The Kill Ring
  53. Kill Ring Concepts
  54. ------------------
  55.    The kill ring records killed text as strings in a list.  A short kill
  56. ring, for example, might look like this:
  57.      ("some text" "a different piece of text" "yet more text")
  58.    New entries in the kill ring go at the front of the list.  When the
  59. list reaches `kill-ring-max' entries in length, adding a new entry
  60. automatically deletes the last entry.
  61.    When kill commands are interwoven with other commands, the killed
  62. portions of text are put into separate entries in the kill ring.  But
  63. when two or more kill commands are executed in succession, the text they
  64. kill forms a single entry, because the second and subsequent consecutive
  65. kill commands append to the entry made by the first one.
  66.    The user can reinsert or "yank" text from any element in the kill
  67. ring.  One of the entries in the ring is considered the "front", and
  68. the simplest yank command yanks that entry.  Other yank commands
  69. "rotate" the ring by designating other entries as the "front".
  70. File: elisp,  Node: Kill Functions,  Next: Yank Commands,  Prev: Kill Ring Concepts,  Up: The Kill Ring
  71. Functions for Killing
  72. ---------------------
  73.    `kill-region' is the usual subroutine for killing text.  Any command
  74. that calls this function is a "kill command" (and should probably have
  75. `kill' in its name).  `kill-region' puts the newly killed text in a new
  76. element at the beginning of the kill ring or adds it to the most recent
  77. element.  It uses the `last-command' variable to keep track of whether
  78. the previous was a kill command, and in such cases appends the killed
  79. text to the most recent entry.
  80.  - Command: kill-region START END
  81.      This function kills the text in the region defined by START and
  82.      END.  The text is deleted but saved in the kill ring.  The value
  83.      is always `nil'.
  84.      In an interactive call, START and END are point and the mark.
  85.      If the buffer is read-only, `kill-region' modifies the kill ring
  86.      just the same, then signals an error without modifying the buffer.
  87.      This is convenient because it lets the user use all the kill
  88.      commands to copy text into the kill ring from a read-only buffer.
  89.  - Command: copy-region-as-kill START END
  90.      This function saves the region defined by START and END on the
  91.      kill ring, but does not delete the text from the buffer.  It
  92.      returns `nil'.  It also indicates the extent of the text copied by
  93.      moving the cursor momentarily, or by displaying a message in the
  94.      echo area.
  95.      Don't use this command in Lisp programs; use `kill-new' or
  96.      `kill-append' instead.  *Note Low Level Kill Ring::.
  97.      In an interactive call, START and END are point and the mark.
  98. File: elisp,  Node: Yank Commands,  Next: Low Level Kill Ring,  Prev: Kill Functions,  Up: The Kill Ring
  99. Functions for Yanking
  100. ---------------------
  101.  - Command: yank &optional ARG
  102.      This function inserts the text in the first entry in the kill ring
  103.      directly before point.  After the yank, the mark is positioned at
  104.      the beginning and point is positioned after the end of the
  105.      inserted text.
  106.      If ARG is a list (which occurs interactively when the user types
  107.      `C-u' with no digits), then `yank' inserts the text as described
  108.      above, but puts point before the yanked text and puts the mark
  109.      after it.  If ARG is a number, then `yank' inserts the ARGth most
  110.      recently killed text.
  111.      `yank' does not alter the contents of the kill ring or rotate it.
  112.      It returns `nil'.
  113.  - Command: yank-pop ARG
  114.      This function replaces the just-yanked text with another batch of
  115.      killed text--another element of the kill ring.
  116.      This command is allowed only immediately after a `yank' or a
  117.      `yank-pop'.  At such a time, the region contains text that was just
  118.      inserted by the previous `yank'.  `yank-pop' deletes that text and
  119.      inserts in its place a different stretch of killed text.  The text
  120.      that is deleted is not inserted into the kill ring, since it is
  121.      already in the kill ring somewhere.
  122.      If ARG is `nil', then the existing region contents are replaced
  123.      with the previous element of the kill ring.  If ARG is numeric,
  124.      then the ARGth previous kill is the replacement.  If ARG is
  125.      negative, a more recent kill is the replacement.
  126.      The sequence of kills in the kill ring wraps around, so that after
  127.      the oldest one comes the newest one, and before the newest one
  128.      goes the oldest.
  129.      The value is always `nil'.
  130. File: elisp,  Node: Low Level Kill Ring,  Next: Internals of Kill Ring,  Prev: Yank Commands,  Up: The Kill Ring
  131. Low Level Kill Ring
  132. -------------------
  133.    These functions and variables provide access to the kill ring at a
  134. lower level, but still convenient for use in Lisp programs.  They take
  135. care of interaction with X Window selections.  They do not exist in
  136. Emacs version 18.
  137.  - Function: current-kill N &optional DO-NOT-MOVE
  138.      The function `current-kill' rotates the yanking pointer in the
  139.      kill ring by N places, and returns the text at that place in the
  140.      ring.
  141.      If the optional second argument DO-NOT-MOVE is non-`nil', then
  142.      `current-kill' doesn't alter the yanking pointer; it just returns
  143.      the Nth kill forward from the current yanking pointer.
  144.      If N is zero, indicating a request for the latest kill,
  145.      `current-kill' calls the value of `interprogram-paste-function'
  146.      (documented below) before consulting the kill ring.
  147.  - Function: kill-new STRING
  148.      This function puts the text STRING into the kill ring as a new
  149.      entry at the front of the ring.  It also discards the oldest entry
  150.      if appropriate.  It also invokes the value of
  151.      `interprogram-cut-function' (see below).
  152.  - Function: kill-append STRING BEFORE-P
  153.      This function appends the text STRING to the first entry in the
  154.      kill ring.  Normally STRING goes at the end of the entry, but if
  155.      BEFORE-P is non-`nil', it goes at the beginning.  This function
  156.      also invokes the value of `interprogram-cut-function' (see below).
  157.  - Variable: interprogram-paste-function
  158.      This variable provides a way of transferring killed text from other
  159.      programs, when you are using a window system.  Its value should be
  160.      `nil' or a function of no arguments.
  161.      If the value is a function, it is called when the "most recent
  162.      kill" value is called for.  If the function returns a non-`nil'
  163.      values, then that value is used as the "most recent kill".  If it
  164.      returns `nil', then the first element of the kill ring is used.
  165.  - Variable: interprogram-cut-function
  166.      This variable provides a way of communicating killed text to and
  167.      from other programs, when you are using a window system.  Its
  168.      value should be `nil' or a function of one argument.
  169.      If the value is a function, it is called whenever the "most recent
  170.      kill" is changed, with the new string of killed text as an
  171.      argument.
  172. File: elisp,  Node: Internals of Kill Ring,  Prev: Low Level Kill Ring,  Up: The Kill Ring
  173. Internals of the Kill Ring
  174. --------------------------
  175.    The variable `kill-ring' holds the kill ring contents, in the form
  176. of a list of strings.  The most recent kill is always at the front of
  177. the list.
  178.    The `kill-ring-yank-pointer' variable points to a link in the kill
  179. ring list, whose CAR is the text that "yank" functions should copy.
  180. Moving `kill-ring-yank-pointer' to a different link is called "rotating
  181. the kill ring".  We call the kill ring a "ring" because the functions
  182. that move the yank pointer wrap around from the end of the list to the
  183. beginning, or vice-versa.  Rotating the ring does not change the value
  184. of `kill-ring'.
  185.    Both `kill-ring' and `kill-ring-yank-pointer' are Lisp variables
  186. whose values are normally lists.  The word "pointer" in the name of the
  187. `kill-ring-yank-pointer' indicates that the variable's purpose is to
  188. identify one element of the list for use by the next yank command.
  189.    The value of `kill-ring-yank-pointer' is always `eq' to one of the
  190. links in the kill ring list.  The element it identifies is the CAR of
  191. that link.  Commands which change the text in the kill ring also set
  192. this variable from `kill-ring'.  The effect is to rotate the ring so
  193. that the newly killed text is at front.
  194.    Here is a diagram that shows the variable `kill-ring-yank-pointer'
  195. pointing to the second entry in the kill ring `("some text" "a
  196. different piece of text" "yet more text")'.
  197.      kill-ring       kill-ring-yank-pointer
  198.        |               |
  199.        |     ___ ___    --->  ___ ___      ___ ___
  200.         --> |___|___|------> |___|___|--> |___|___|--> nil
  201.               |                |            |
  202.               |                |            |
  203.               |                |             -->"yet more text"
  204.               |                |
  205.               |                 --> "a different piece of text"
  206.               |
  207.                --> "some text"
  208. This circumstance might occur after `C-y' (`yank') immediately followed
  209. by `M-y' (`yank-pop').
  210.  - Variable: kill-ring
  211.      List of killed text sequences, most recently killed first.
  212.  - Variable: kill-ring-yank-pointer
  213.      This variable's value indicates which element of the kill ring is
  214.      at the "front" of the ring for yanking.  More precisely, the value
  215.      is a sublist of the value of `kill-ring', and its CAR is the kill
  216.      string that `C-y' should yank.
  217.  - User Option: kill-ring-max
  218.      The value of this variable is the maximum length to which the kill
  219.      ring can grow, before elements are thrown away at the end.  The
  220.      default value for `kill-ring-max' is 30.
  221. File: elisp,  Node: Undo,  Next: Maintaining Undo,  Prev: The Kill Ring,  Up: Text
  222.    Most buffers have an "undo list" which records all changes made to
  223. the buffer's text so that they can be undone.  (The buffers which don't
  224. have one are usually special-purpose buffers for which Emacs assumes
  225. that undoing is not useful.)  All the primitives which modify the text
  226. in the buffer automatically add elements to the front of the undo list,
  227. which you can find in the variable `buffer-undo-list'.
  228.  - Variable: buffer-undo-list
  229.      This variable's value is the undo list of the current buffer.  A
  230.      value of `t' disables the recording of undo information.
  231.    Here are the kinds of elements an undo list can have:
  232. `INTEGER'
  233.      This kind of element records a previous value of point.  Ordinary
  234.      cursor motion does not get any sort of undo record, but these
  235.      entries are used to record where point was before a deletion.
  236. `(BEG . END)'
  237.      This kind of element indicates how to delete text that was
  238.      inserted.  Upon insertion, the text occupied the range BEG-END in
  239.      the buffer.
  240. `(POS . DELETED)'
  241.      This kind of element indicates how to reinsert text that was
  242.      deleted.  The deleted text itself is the string DELETED.  The
  243.      place to reinsert it is POS.
  244. `(t HIGH . LOW)'
  245.      This kind of element indicates that an unmodified buffer became
  246.      modified.  The elements HIGH and LOW are two integers, each
  247.      recording 16 bits of the visited file's modification time as of
  248.      when it was previously visited or saved.  `primitive-undo' uses
  249.      those values to determine whether to mark the buffer as unmodified
  250.      once again; it does so only if the file's modification time
  251.      matches those numbers.
  252. `(nil PROPERTY VALUE BEG . END)'
  253.      This kind of element records a change in a text property.  Here's
  254.      how you might undo the change:
  255.           (put-text-property BEG END
  256.                              PROPERTY VALUE)
  257. `nil'
  258.      This element is a boundary.  The function `undo-boundary' adds
  259.      these elements.  The elements between two boundaries are called a
  260.      "change group"; normally, each change group corresponds to one
  261.      keyboard command, and undo commands normally undo an entire group
  262.      as a unit.
  263.  - Function: undo-boundary
  264.      This function places a boundary element in the undo list.  The undo
  265.      command stops at such a boundary, and successive undo commands undo
  266.      to earlier and earlier boundaries.  This function returns `nil'.
  267.      The editor command loop automatically creates an undo boundary
  268.      between keystroke commands.  Thus, each undo normally undoes the
  269.      effects of one command.  Calling this function explicitly is
  270.      useful for splitting the effects of a command into more than one
  271.      unit.  For example, `query-replace' calls this function after each
  272.      replacement so that the user can undo individual replacements one
  273.      by one.
  274.  - Function: primitive-undo COUNT LIST
  275.      This is the basic function for undoing elements of an undo list.
  276.      It undoes the first COUNT elements of LIST, returning the rest of
  277.      LIST.  You could write this function in Lisp, but it is convenient
  278.      to have it in C.
  279.      `primitive-undo' adds elements to the buffer's undo list.  Undo
  280.      commands avoid confusion by saving the undo list value at the
  281.      beginning of a sequence of undo operations.  Then the undo
  282.      operations use and update the saved value.  The new elements added
  283.      by undoing never get into the saved value, so they don't cause any
  284.      trouble.
  285. File: elisp,  Node: Maintaining Undo,  Next: Auto Filling,  Prev: Undo,  Up: Text
  286. Maintaining Undo Lists
  287. ======================
  288.    This section describes how to enable and disable undo information for
  289. a given buffer.  It also explains how data from the undo list is
  290. discarded automatically so it doesn't get too big.
  291.    Recording of undo information in a newly created buffer is normally
  292. enabled to start with; but if the buffer name starts with a space, the
  293. undo recording is initially disabled.  You can explicitly enable or
  294. disable undo recording with the following two functions, or by setting
  295. `buffer-undo-list' yourself.
  296.  - Command: buffer-enable-undo &optional BUFFER-OR-NAME
  297.      This function enables recording undo information for buffer
  298.      BUFFER-OR-NAME, so that subsequent changes can be undone.  If no
  299.      argument is supplied, then the current buffer is used.  This
  300.      function does nothing if undo recording is already enabled in the
  301.      buffer.  It returns `nil'.
  302.      In an interactive call, BUFFER-OR-NAME is the current buffer.  You
  303.      cannot specify any other buffer.
  304.  - Function: buffer-disable-undo BUFFER
  305.  - Function: buffer-flush-undo BUFFER
  306.      This function discards the undo list of BUFFER, and disables
  307.      further recording of undo information.  As a result, it is no
  308.      longer possible to undo either previous changes or any subsequent
  309.      changes.  If the undo list of BUFFER is already disabled, this
  310.      function has no effect.
  311.      This function returns `nil'.  It cannot be called interactively.
  312.      The name `buffer-flush-undo' is not considered obsolete, but the
  313.      preferred name `buffer-disable-undo' was not provided in Emacs
  314.      versions 18 and earlier.
  315.    As editing continues, undo lists get longer and longer.  To prevent
  316. them from using up all available memory space, garbage collection trims
  317. them back to size limits you can set.  (For this purpose, the "size" of
  318. an undo list measures the cons cells that make up the list, plus the
  319. strings of deleted text.)  Two variables control the range of acceptable
  320. sizes: `undo-limit' and `undo-strong-limit'.
  321.  - Variable: undo-limit
  322.      This is the soft limit for the acceptable size of an undo list.
  323.      The change group at which this size is exceeded is the last one
  324.      kept.
  325.  - Variable: undo-strong-limit
  326.      The upper limit for the acceptable size of an undo list.  The
  327.      change group at which this size is exceeded is discarded itself
  328.      (along with all subsequent changes).  There is one exception:
  329.      garbage collection always keeps the very last change group no
  330.      matter how big it is.
  331. File: elisp,  Node: Filling,  Next: Sorting,  Prev: Auto Filling,  Up: Text
  332. Filling
  333. =======
  334.    "Filling" means adjusting the lengths of lines (by moving words
  335. between them) so that they are nearly (but no greater than) a specified
  336. maximum width.  Additionally, lines can be "justified", which means
  337. that spaces are inserted between words to make the line exactly the
  338. specified width.  The width is controlled by the variable
  339. `fill-column'.  For ease of reading, lines should be no longer than 70
  340. or so columns.
  341.    You can use Auto Fill mode (*note Auto Filling::.) to fill text
  342. automatically as you insert it, but changes to existing text may leave
  343. it improperly filled.  Then you must fill the text explicitly.
  344.    Most of the functions in this section return values that are not
  345. meaningful.
  346.  - Command: fill-paragraph JUSTIFY-FLAG
  347.      This function fills the paragraph at or after point.  If
  348.      JUSTIFY-FLAG is non-`nil', each line is justified as well.  It
  349.      uses the ordinary paragraph motion commands to find paragraph
  350.      boundaries.
  351.  - Command: fill-region START END &optional JUSTIFY-FLAG
  352.      This function fills each of the paragraphs in the region from
  353.      START to END.  It justifies as well if JUSTIFY-FLAG is non-`nil'.
  354.      (In an interactive call, this is true if there is a prefix
  355.      argument.)
  356.      The variable `paragraph-separate' controls how to distinguish
  357.      paragraphs.
  358.  - Command: fill-individual-paragraphs START END &optional JUSTIFY-FLAG
  359.           MAIL-FLAG
  360.      This function fills each paragraph in the region according to its
  361.      individual fill prefix.  Thus, if the lines of a paragraph are
  362.      indented with spaces, the filled paragraph will continue to be
  363.      indented in the same fashion.
  364.      The first two arguments, START and END, are the beginning and end
  365.      of the region that will be filled.  The third and fourth
  366.      arguments, JUSTIFY-FLAG and MAIL-FLAG, are optional.  If
  367.      JUSTIFY-FLAG is non-`nil', the paragraphs are justified as well as
  368.      filled.  If MAIL-FLAG is non-`nil', the function is told that it
  369.      is operating on a mail message and therefore should not fill the
  370.      header lines.
  371.      Ordinarily, `fill-individual-paragraphs' regards each change in
  372.      indentation as starting a new paragraph.  If
  373.      `fill-individual-varying-indent' is non-`nil', then only separator
  374.      lines separate paragraphs.  That mode can handle paragraphs with
  375.      extra indentation on the first line.
  376.  - User Option: fill-individual-varying-indent
  377.      This variable alters the action of `fill-individual-paragraphs' as
  378.      described above.
  379.  - Command: fill-region-as-paragraph START END &optional JUSTIFY-FLAG
  380.      This function considers a region of text as a paragraph and fills
  381.      it.  If the region was made up of many paragraphs, the blank lines
  382.      between paragraphs are removed.  This function justifies as well
  383.      as filling when JUSTIFY-FLAG is non-`nil'.  In an interactive
  384.      call, any prefix argument requests justification.
  385.      In Adaptive Fill mode, which is enabled by default,
  386.      `fill-region-as-paragraph' on an indented paragraph when there is
  387.      no fill prefix uses the indentation of the second line of the
  388.      paragraph as the fill prefix.
  389.  - Command: justify-current-line
  390.      This function inserts spaces between the words of the current line
  391.      so that the line ends exactly at `fill-column'.  It returns `nil'.
  392.  - User Option: fill-column
  393.      This buffer-local variable specifies the maximum width of filled
  394.      lines.  Its value should be an integer, which is a number of
  395.      columns.  All the filling, justification and centering commands
  396.      are affected by this variable, including Auto Fill mode (*note
  397.      Auto Filling::.).
  398.      As a practical matter, if you are writing text for other people to
  399.      read, you should set `fill-column' to no more than 70.  Otherwise
  400.      the line will be too long for people to read comfortably, and this
  401.      can make the text seem clumsy.
  402.  - Variable: default-fill-column
  403.      The value of this variable is the default value for `fill-column'
  404.      in buffers that do not override it.  This is the same as
  405.      `(default-value 'fill-column)'.
  406.      The default value for `default-fill-column' is 70.
  407. File: elisp,  Node: Auto Filling,  Next: Filling,  Prev: Maintaining Undo,  Up: Text
  408. Auto Filling
  409. ============
  410.    "Filling" breaks text into lines that are no more than a specified
  411. number of columns wide.  Filled lines end between words, and therefore
  412. may have to be shorter than the maximum width.
  413.    Auto Fill mode is a minor mode in which Emacs fills lines
  414. automatically as text as inserted.  This section describes the hook and
  415. the two variables used by Auto Fill mode.  For a description of
  416. functions that you can call manually to fill and justify text, see
  417. *Note Filling::.
  418.  - Variable: auto-fill-function
  419.      The value of this variable should be a function (of no arguments)
  420.      to be called after self-inserting a space at a column beyond
  421.      `fill-column'.  It may be `nil', in which case nothing special is
  422.      done.
  423.      The default value for `auto-fill-function' is `do-auto-fill', a
  424.      function whose sole purpose is to implement the usual strategy for
  425.      breaking a line.
  426.           In older Emacs versions, this variable was named
  427.           `auto-fill-hook', but since it is not called with the
  428.           standard convention for hooks, it was renamed to
  429.           `auto-fill-function' in version 19.
  430. File: elisp,  Node: Sorting,  Next: Indentation,  Prev: Filling,  Up: Text
  431. Sorting Text
  432. ============
  433.    The sorting commands described in this section all rearrange text in
  434. a buffer.  This is in contrast to the function `sort', which rearranges
  435. the order of the elements of a list (*note Rearrangement::.).  The
  436. values returned by these commands are not meaningful.
  437.  - Command: sort-regexp-fields REVERSE RECORD-REGEXP KEY-REGEXP START
  438.           END
  439.      This command sorts the region between START and END alphabetically
  440.      as specified by RECORD-REGEXP and KEY-REGEXP.  If REVERSE is a
  441.      negative integer, then sorting is in reverse order.
  442.      Alphabetical sorting means that two sort keys are compared by
  443.      comparing the first characters of each, the second characters of
  444.      each, and so on.  If a mismatch is found, it means that the sort
  445.      keys are unequal; the sort key whose character is less at the
  446.      point of first mismatch is the lesser sort key.  The individual
  447.      characters are compared according to their numerical values.
  448.      Since Emacs uses the ASCII character set, the ordering in that set
  449.      determines alphabetical order.
  450.      The value of the RECORD-REGEXP argument specifies the textual
  451.      units or "records" that should be sorted.  At the end of each
  452.      record, a search is done for this regular expression, and the text
  453.      that matches it is the next record.  For example, the regular
  454.      expression `^.+$', which matches lines with at least one character
  455.      besides a newline, would make each such line into a sort record.
  456.      *Note Regular Expressions::, for a description of the syntax and
  457.      meaning of regular expressions.
  458.      The value of the KEY-REGEXP argument specifies what part of each
  459.      record is to be compared against the other records.  The
  460.      KEY-REGEXP could match the whole record, or only a part.  In the
  461.      latter case, the rest of the record has no effect on the sorted
  462.      order of records, but it is carried along when the record moves to
  463.      its new position.
  464.      The KEY-REGEXP argument can refer to the text matched by a
  465.      subexpression of RECORD-REGEXP, or it can be a regular expression
  466.      on its own.
  467.      If KEY-REGEXP is:
  468.     `\DIGIT'
  469.           then the text matched by the DIGITth `\(...\)' parenthesis
  470.           grouping in RECORD-REGEXP is used for sorting.
  471.     `\&'
  472.           then the whole record is used for sorting.
  473.     a regular expression
  474.           then the function searches for a match for the regular
  475.           expression within the record.  If such a match is found, it
  476.           is used for sorting.  If a match for KEY-REGEXP is not found
  477.           within a record then that record is ignored, which means its
  478.           position in the buffer is not changed.  (The other records
  479.           may move around it.)
  480.      For example, if you plan to sort all the lines in the region by the
  481.      first word on each line starting with the letter `f', you should
  482.      set RECORD-REGEXP to `^.*$' and set KEY-REGEXP to `\<f\w*\>'.  The
  483.      resulting expression looks like this:
  484.           (sort-regexp-fields nil "^.*$" "\\<f\\w*\\>"
  485.                               (region-beginning)
  486.                               (region-end))
  487.      If you call `sort-regexp-fields' interactively, you are prompted
  488.      for RECORD-REGEXP and KEY-REGEXP in the minibuffer.
  489.  - Command: sort-subr REVERSE NEXTRECFUN ENDRECFUN &optional
  490.           STARTKEYFUN ENDKEYFUN
  491.      This command is the general text sorting routine that divides a
  492.      buffer into records and sorts them.  The functions `sort-lines',
  493.      `sort-paragraphs', `sort-pages', `sort-fields',
  494.      `sort-regexp-fields' and `sort-numeric-fields' all use `sort-subr'.
  495.      To understand how `sort-subr' works, consider the whole accessible
  496.      portion of the buffer as being divided into disjoint pieces called
  497.      "sort records".  A portion of each sort record (perhaps all of it)
  498.      is designated as the sort key.  The records are rearranged in the
  499.      buffer in order by their sort keys.  The records may or may not be
  500.      contiguous.
  501.      Usually, the records are rearranged in order of ascending sort key.
  502.      If the first argument to the `sort-subr' function, REVERSE, is
  503.      non-`nil', the sort records are rearranged in order of descending
  504.      sort key.
  505.      The next four arguments to `sort-subr' are functions that are
  506.      called to move point across a sort record.  They are called many
  507.      times from within `sort-subr'.
  508.        1. NEXTRECFUN is called with point at the end of a record.  This
  509.           function moves point to the start of the next record.  The
  510.           first record is assumed to start at the position of point
  511.           when `sort-subr' is called.  (Therefore, you should usually
  512.           move point to the beginning of the buffer before calling
  513.           `sort-subr'.)
  514.           This function can indicate there are no more sort records by
  515.           leaving point at the end of the buffer.
  516.        2. ENDRECFUN is called with point within a record.  It moves
  517.           point to the end of the record.
  518.        3. STARTKEYFUN is called to move point from the start of a
  519.           record to the start of the sort key.  This argument is
  520.           optional.  If supplied, the function should either return a
  521.           non-`nil' value to be used as the sort key, or return `nil'
  522.           to indicate that the sort key is in the buffer starting at
  523.           point.  In the latter case, ENDKEYFUN is called to find the
  524.           end of the sort key.
  525.        4. ENDKEYFUN is called to move point from the start of the sort
  526.           key to the end of the sort key.  This argument is optional.
  527.           If STARTKEYFUN returns `nil' and this argument is omitted (or
  528.           `nil'), then the sort key extends to the end of the record.
  529.           There is no need for ENDKEYFUN if STARTKEYFUN returns a
  530.           non-`nil' value.
  531.      As an example of `sort-subr', here is the complete function
  532.      definition for `sort-lines':
  533.           ;; Note that the first two lines of doc string
  534.           ;; are effectively one line when viewed by a user.
  535.           (defun sort-lines (reverse beg end)
  536.             "Sort lines in region alphabetically;\
  537.            argument means descending order.
  538.           Called from a program, there are three arguments:
  539.           REVERSE (non-nil means reverse order),
  540.           and BEG and END (the region to sort)."
  541.             (interactive "P\nr")
  542.             (save-restriction
  543.               (narrow-to-region beg end)
  544.               (goto-char (point-min))
  545.               (sort-subr reverse
  546.                          'forward-line
  547.                          'end-of-line)))
  548.      Here `forward-line' moves point to the start of the next record,
  549.      and `end-of-line' moves point to the end of record.  We do not pass
  550.      the arguments STARTKEYFUN and ENDKEYFUN, because the entire record
  551.      is used as the sort key.
  552.      The `sort-paragraphs' function is very much the same, except that
  553.      its `sort-subr' call looks like this:
  554.           (sort-subr reverse
  555.                      (function
  556.                       (lambda ()
  557.                         (skip-chars-forward "\n \t\f")))
  558.                      'forward-paragraph)
  559.  - Command: sort-lines REVERSE START END
  560.      This command sorts lines in the region between START and END
  561.      alphabetically.  If REVERSE is non-`nil', the sort is in reverse
  562.      order.
  563.  - Command: sort-paragraphs REVERSE START END
  564.      This command sorts paragraphs in the region between START and END
  565.      alphabetically.  If REVERSE is non-`nil', the sort is in reverse
  566.      order.
  567.  - Command: sort-pages REVERSE START END
  568.      This command sorts pages in the region between START and END
  569.      alphabetically.  If REVERSE is non-`nil', the sort is in reverse
  570.      order.
  571.  - Command: sort-fields FIELD START END
  572.      This command sorts lines in the region between START and END,
  573.      comparing them alphabetically by the FIELDth field of each line.
  574.      Fields are separated by whitespace and numbered starting from 1.
  575.      If FIELD is negative, sorting is by the -FIELDth field from the
  576.      end of the line.  This command is useful for sorting tables.
  577.  - Command: sort-numeric-fields FIELD START END
  578.      This command sorts lines in the region between START and END,
  579.      comparing them numerically by the FIELDth field of each line.
  580.      Fields are separated by whitespace and numbered starting from 1.
  581.      The specified field must contain a number in each line of the
  582.      region.  If FIELD is negative, sorting is by the -FIELDth field
  583.      from the end of the line.  This command is useful for sorting
  584.      tables.
  585.  - Command: sort-columns REVERSE &optional BEG END
  586.      This command sorts the lines in the region between BEG and END,
  587.      comparing them alphabetically by a certain range of columns.  The
  588.      column positions of BEG and END bound the range of columns to sort
  589.      on.
  590.      If REVERSE is non-`nil', the sort is in reverse order.
  591.      One unusual thing about this command is that the entire line
  592.      containing position BEG, and the entire line containing position
  593.      END, are included in the region sorted.
  594.      Note that `sort-columns' uses the `sort' utility program, and so
  595.      cannot work properly on text containing tab characters.  Use `M-x
  596.      `untabify'' to convert tabs to spaces before sorting.
  597.      The `sort-columns' function did not work on VMS prior to Emacs 19.
  598. File: elisp,  Node: Indentation,  Next: Columns,  Prev: Sorting,  Up: Text
  599. Indentation
  600. ===========
  601.    The indentation functions are used to examine, move to, and change
  602. whitespace that is at the beginning of a line.  Some of the functions
  603. can also change whitespace elsewhere on a line.  Indentation always
  604. counts from zero at the left margin.
  605. * Menu:
  606. * Primitive Indent::      Functions used to count and insert indentation.
  607. * Mode-Specific Indent::  Customize indentation for different modes.
  608. * Region Indent::         Indent all the lines in a region.
  609. * Relative Indent::       Indent the current line based on previous lines.
  610. * Indent Tabs::           Adjustable, typewriter-like tab stops.
  611. * Motion by Indent::      Move to first non-blank character.
  612. File: elisp,  Node: Primitive Indent,  Next: Mode-Specific Indent,  Up: Indentation
  613. Indentation Primitives
  614. ----------------------
  615.    This section describes the primitive functions used to count and
  616. insert indentation.  The functions in the following sections use these
  617. primitives.
  618.  - Function: current-indentation
  619.      This function returns the indentation of the current line, which is
  620.      the horizontal position of the first nonblank character.  If the
  621.      contents are entirely blank, then this is the horizontal position
  622.      of the end of the line.
  623.  - Command: indent-to COLUMN &optional MINIMUM
  624.      This function indents from point with tabs and spaces until COLUMN
  625.      is reached.  If MINIMUM is specified and non-`nil', then at least
  626.      that many spaces are inserted even if this requires going beyond
  627.      COLUMN.  The value is the column at which the inserted indentation
  628.      ends.
  629.  - User Option: indent-tabs-mode
  630.      If this variable is non-`nil', indentation functions can insert
  631.      tabs as well as spaces.  Otherwise, they insert only spaces.
  632.      Setting this variable automatically makes it local to the current
  633.      buffer.
  634. File: elisp,  Node: Mode-Specific Indent,  Next: Region Indent,  Prev: Primitive Indent,  Up: Indentation
  635. Indentation Controlled by Major Mode
  636. ------------------------------------
  637.    An important function of each major mode is to customize the TAB key
  638. to indent properly for the language being edited.  This section
  639. describes the mechanism of the TAB key and how to control it.  The
  640. functions in this section return unpredictable values.
  641.  - Variable: indent-line-function
  642.      This variable's value is the function to be used by TAB (and
  643.      various commands) to indent the current line.  The command
  644.      `indent-according-to-mode' does no more than call this function.
  645.      In Lisp mode, the value is the symbol `lisp-indent-line'; in C
  646.      mode, `c-indent-line'; in Fortran mode, `fortran-indent-line'.  In
  647.      Fundamental mode, Text mode, and many other modes with no standard
  648.      for indentation, the value is `indent-to-left-margin' (which is the
  649.      default value).
  650.  - Command: indent-according-to-mode
  651.      This command calls the function in `indent-line-function' to
  652.      indent the current line in a way appropriate for the current major
  653.      mode.
  654.  - Command: indent-for-tab-command
  655.      This command calls the function in `indent-line-function' to
  656.      indent the current line, except that if that function is
  657.      `indent-to-left-margin', `insert-tab' is called instead.  (That is
  658.      a trivial command which inserts a tab character.)
  659.  - Variable: left-margin
  660.      This variable is the column to which the default
  661.      `indent-line-function' will indent.  (That function is
  662.      `indent-to-left-margin'.)  In Fundamental mode, LFD indents to
  663.      this column.  This variable automatically becomes buffer-local when
  664.      set in any fashion.
  665.  - Function: indent-to-left-margin
  666.      This is the default `indent-line-function', used in Fundamental
  667.      mode, Text mode, etc.  Its effect is to adjust the indentation at
  668.      the beginning of the current line to the value specified by the
  669.      variable `left-margin'.  This may involve either inserting or
  670.      deleting whitespace.
  671.  - Command: newline-and-indent
  672.      This function inserts a newline, then indents the new line (the one
  673.      following the newline just inserted) according to the major mode.
  674.      Indentation is done using the current `indent-line-function'.  In
  675.      programming language modes, this is the same thing TAB does, but
  676.      in some text modes, where TAB inserts a tab, `newline-and-indent'
  677.      indents to the column specified by `left-margin'.
  678.  - Command: reindent-then-newline-and-indent
  679.      This command reindents the current line, inserts a newline at
  680.      point, and then reindents the new line (the one following the
  681.      newline just inserted).
  682.      Indentation of both lines is done according to the current major
  683.      mode; this means that the current value of `indent-line-function'
  684.      is called.  In programming language modes, this is the same thing
  685.      TAB does, but in some text modes, where TAB inserts a tab,
  686.      `reindent-then-newline-and-indent' indents to the column specified
  687.      by `left-margin'.
  688. File: elisp,  Node: Region Indent,  Next: Relative Indent,  Prev: Mode-Specific Indent,  Up: Indentation
  689. Indenting an Entire Region
  690. --------------------------
  691.    This section describes commands which indent all the lines in the
  692. region.  They return unpredictable values.
  693.  - Command: indent-region START END TO-COLUMN
  694.      This command indents each nonblank line starting between START
  695.      (inclusive) and END (exclusive).  If TO-COLUMN is `nil',
  696.      `indent-region' indents each nonblank line by calling the current
  697.      mode's indentation function, the value of `indent-line-function'.
  698.      If TO-COLUMN is non-`nil', it should be an integer specifying the
  699.      number of columns of indentation; then this function gives each
  700.      line exactly that much indentation, by either adding or deleting
  701.      whitespace.
  702.      If there is a fill prefix, `indent-region' indents each line by
  703.      making it start with the fill prefix.
  704.  - Variable: indent-region-function
  705.      The value of this variable is a function that can be used by
  706.      `indent-region' as a short cut.  You should design the function so
  707.      that it will produce the same results as indenting the lines of the
  708.      region one by one (but presumably faster).
  709.      If the value is `nil', there is no short cut, and `indent-region'
  710.      actually works line by line.
  711.      A short cut function is useful in modes such as C mode and Lisp
  712.      mode, where the `indent-line-function' must scan from the
  713.      beginning of the function: applying it to each line would be
  714.      quadratic in time.  The short cut can update the scan information
  715.      as it moves through the lines indenting them; this takes linear
  716.      time.  If indenting a line individually is fast, there is no need
  717.      for a short cut.
  718.      `indent-region' with a non-`nil' argument has a different
  719.      definition and does not use this variable.
  720.  - Command: indent-rigidly START END COUNT
  721.      This command indents all lines starting between START (inclusive)
  722.      and END (exclusive) sideways by `count' columns.  This "preserves
  723.      the shape" of the affected region, moving it as a rigid unit.
  724.      Consequently, this command is useful not only for indenting
  725.      regions of unindented text, but also for indenting regions of
  726.      formatted code.
  727.      For example, if COUNT is 3, this command adds 3 columns of
  728.      indentation to each of the lines beginning in the region specified.
  729.      In Mail mode, `C-c C-y' (`mail-yank-original') uses
  730.      `indent-rigidly' to indent the text copied from the message being
  731.      replied to.
  732.  - Function: indent-code-rigidly START END COLUMNS &optional
  733.           NOCHANGE-REGEXP
  734.      This is like `indent-rigidly', except that it doesn't alter lines
  735.      that start within strings or comments.
  736.      In addition, it doesn't alter a line if NOCHANGE-REGEXP matches at
  737.      the beginning of the line (if NOCHANGE-REGEXP is non-`nil').
  738. File: elisp,  Node: Relative Indent,  Next: Indent Tabs,  Prev: Region Indent,  Up: Indentation
  739. Indentation Relative to Previous Lines
  740. --------------------------------------
  741.    This section describes two commands which indent the current line
  742. based on the contents of previous lines.
  743.  - Command: indent-relative &optional UNINDENTED-OK
  744.      This function inserts whitespace at point, extending to the same
  745.      column as the next "indent point" of the previous nonblank line.
  746.      An indent point is a non-whitespace character following
  747.      whitespace.  The next indent point is the first one at a column
  748.      greater than the current column of point.  For example, if point
  749.      is underneath and to the left of the first non-blank character of
  750.      a line of text, it moves to that column by inserting whitespace.
  751.      If the previous nonblank line has no next indent point (i.e., none
  752.      at a great enough column position), this function either does
  753.      nothing (if UNINDENTED-OK is non-`nil') or calls `tab-to-tab-stop'.
  754.      Thus, if point is underneath and to the right of the last column
  755.      of a short line of text, this function moves point to the next tab
  756.      stop by inserting whitespace.
  757.      This command returns an unpredictable value.
  758.      In the following example, point is at the beginning of the second
  759.      line:
  760.                       This line is indented twelve spaces.
  761.           -!-The quick brown fox jumped.
  762.      Evaluation of the expression `(indent-relative nil)' produces the
  763.      following:
  764.                       This line is indented twelve spaces.
  765.                       -!-The quick brown fox jumped.
  766.      In this example, point is between the `m' and `p' of `jumped':
  767.                       This line is indented twelve spaces.
  768.           The quick brown fox jum-!-ped.
  769.      Evaluation of the expression `(indent-relative nil)' produces the
  770.      following:
  771.                       This line is indented twelve spaces.
  772.           The quick brown fox jum  -!-ped.
  773.  - Command: indent-relative-maybe
  774.      This command indents the current line like the previous nonblank
  775.      line.  The function consists of a call to `indent-relative' with a
  776.      non-`nil' value passed to the UNINDENTED-OK optional argument.
  777.      The value is unpredictable.
  778.      If the previous line has no indentation, the current line is given
  779.      no indentation (any existing indentation is deleted); if the
  780.      previous nonblank line has no indent points beyond the column at
  781.      which point starts, nothing is changed.
  782. File: elisp,  Node: Indent Tabs,  Next: Motion by Indent,  Prev: Relative Indent,  Up: Indentation
  783. Adjustable "Tab Stops"
  784. ----------------------
  785.    This section explains the mechanism for user-specified "tab stops"
  786. and the mechanisms which use and set them.  The name "tab stops" is
  787. used because the feature is similar to that of the tab stops on a
  788. typewriter.  The feature works by inserting an appropriate number of
  789. spaces and tab characters to reach the designated position, like the
  790. other indentation functions; it does not affect the display of tab
  791. characters in the buffer (*note Usual Display::.).  Note that the TAB
  792. character as input uses this tab stop feature only in a few major
  793. modes, such as Text mode.
  794.  - Function: tab-to-tab-stop
  795.      This function inserts spaces or tabs up to the next tab stop column
  796.      defined by `tab-stop-list'.  It searches the list for an element
  797.      greater than the current column number, and uses that element as
  798.      the column to indent to.  If no such element is found, then
  799.      nothing is done.
  800.  - User Option: tab-stop-list
  801.      This variable is the list of tab stop columns used by
  802.      `tab-to-tab-stops'.  The elements should be integers in increasing
  803.      order.  The tab stop columns need not be evenly spaced.
  804.      Use `M-x edit-tab-stops' to edit the location of tab stops
  805.      interactively.
  806. File: elisp,  Node: Motion by Indent,  Prev: Indent Tabs,  Up: Indentation
  807. Indentation-Based Motion Commands
  808. ---------------------------------
  809.    These commands, primarily for interactive use, act based on the
  810. indentation in the text.
  811.  - Command: back-to-indentation
  812.      This command moves point to the first non-whitespace character in
  813.      the current line (which is the line in which point is located).
  814.      It returns `nil'.
  815.  - Command: backward-to-indentation ARG
  816.      This command moves point backward ARG lines and then to the first
  817.      nonblank character on that line.  It returns `nil'.
  818.  - Command: forward-to-indentation ARG
  819.      This command moves point forward ARG lines and then to the first
  820.      nonblank character on that line.  It returns `nil'.
  821. File: elisp,  Node: Columns,  Next: Case Changes,  Prev: Indentation,  Up: Text
  822. Counting Columns
  823. ================
  824.    The column functions convert between a character position (counting
  825. characters from the beginning of the buffer) and a column position
  826. (counting screen characters from the beginning of a line).
  827.    Column number computations ignore the width of the window and the
  828. amount of horizontal scrolling.  Consequently, a column value can be
  829. arbitrarily high.  The first (or leftmost) column is numbered 0.
  830.    A character counts according to the number of columns it occupies on
  831. the screen.  This means control characters count as occupying 2 or 4
  832. columns, depending upon the value of `ctl-arrow', and tabs count as
  833. occupying a number of columns that depends on the value of `tab-width'
  834. and on the column where the tab begins.  *Note Usual Display::.
  835.  - Function: current-column
  836.      This function returns the horizontal position of point, measured in
  837.      columns, counting from 0 at the left margin.  The column count is
  838.      calculated by adding together the widths of all the displayed
  839.      representations of the characters between the start of the current
  840.      line and point.
  841.      For a more complicated example of the use of `current-column', see
  842.      the description of `count-lines' in *Note Text Lines::.
  843.  - Function: move-to-column COLUMN &optional FORCE
  844.      This function moves point to COLUMN in the current line.  The
  845.      calculation of COLUMN takes into account the widths of all the
  846.      displayed representations of the characters between the start of
  847.      the line and point.
  848.      If the argument COLUMN is greater than the column position of the
  849.      end of the line, point moves to the end of the line.  If COLUMN is
  850.      negative, point moves to the beginning of the line.
  851.      If it is impossible to move to column COLUMN because that is in
  852.      the middle of a multicolumn character such as a tab, point moves
  853.      to the end of that character.  However, if FORCE is non-`nil', and
  854.      COLUMN is in the middle of a tab, then `move-to-column' converts
  855.      the tab into spaces so that it can move precisely to column COLUMN.
  856.      The argument FORCE also has an effect if the line isn't long
  857.      enough to reach column COLUMN; in that case, it says to indent at
  858.      the end of the line to reach that column.
  859.      If COLUMN is not an integer, an error is signaled.
  860.      The return value is the column number actually moved to.
  861.